home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 22 / AACD 22.iso / AACD / Sound / Subspace68k / src / Deltafields4.c < prev    next >
Encoding:
C/C++ Source or Header  |  2001-05-04  |  5.1 KB  |  264 lines
  1.  
  2. #include <exec/types.h>
  3. #include <math.h>
  4.  
  5. #ifdef __SASC
  6.     #define M_PI PI
  7. #endif
  8. #ifdef __VBCC__
  9. //#define   M_PI 3.14159265358979323846
  10. #define   M_PI 3.1415927
  11. #endif
  12.  
  13. float rnd(float max);
  14. float sgn(float val);
  15. float trnc(float value);
  16.  
  17. extern int TimeWave;
  18. extern int LineToCalc;
  19. extern WORD     *PluginSamples;
  20.  
  21. float A0, A1, A2, A3, A4, A5, A6, A7, A8, A9;
  22.  
  23. void PrepareConstants(UBYTE FieldNum) {
  24.     switch(FieldNum) {
  25.         case 0:
  26.         break;
  27.         case 1:
  28.         break;
  29.         case 2:
  30.         break;
  31.         case 3:
  32.         break;
  33.         case 4:
  34.             A0 = rnd(M_PI);
  35.             A1 = .01*(.5 + rnd(.5) + rnd(.5));
  36.             A2 =  .1*(.5 + rnd(.5) + rnd(.5));
  37.         break;
  38.         case 5:
  39.         break;
  40.         case 6:
  41.         break;
  42.         case 7:
  43.             A0 = 2    + rnd(30);
  44.             A1 = 0.01 + rnd(0.05);
  45.         break;
  46.         case 8:
  47.             A0 = 14;
  48.             A1 = 0.08;
  49.             A2 = 3 + rnd(3);
  50.             A3 = 0.01;
  51.         break;
  52.         case 9:
  53.         break;
  54.         case 10: // Radial Breakaway
  55.         break;
  56.         case 11: // SOLs Waves
  57.         break;
  58.         case 12: // SOLs Growth Formula
  59.             A0 = 2.0 * ( 2.0 + rnd(12));
  60.             A1 = 0.01 + rnd(0.03);
  61.         break;
  62.         case 13: // Tiles
  63.             A0 = 1.90  * (1.0 + rnd(2.0));
  64.             A1 = 0.005 * (1.0 + rnd(1.0));
  65.         break;
  66.         case 14: // In or out, inner Turn
  67.             A0 = 0.95 + rnd(.06);
  68.         break;
  69.         case 15: // Slidering
  70.             A0 = 8.0  + rnd(16);
  71.             A1 = 0.03 + rnd(.05);
  72.             A2 = (0.006 + rnd( .006 )) * sgn(0.5-rnd(1.0));
  73.             A3 = A0 / 2.0;
  74.         break;
  75.         case 16: // Sine Multi-Circ
  76.         break;
  77.         case 17: // Noise
  78.         break;
  79.  
  80.         case 18: // The MAW
  81.         break;
  82.     }
  83. }
  84.  
  85. void CalcLine(LONG *Zoom, int Width, int Height, UBYTE FieldNum) {
  86.     LONG i,xs,ys,xd,yd;
  87.  
  88.     float scale,greater;
  89.     float xsf,ysf,xdf,ydf;
  90.     float rsf,tsf,rdf,tdf;
  91.     float wf,hf;
  92.  
  93.     wf=(float)Width;
  94.     hf=(float)Height;
  95.  
  96.     greater=1.0;
  97.     if(wf > greater) greater = wf;
  98.     if(hf > greater) greater = hf;
  99.  
  100.     scale = 1.0 / (greater/2.0);
  101.  
  102.     yd = LineToCalc;
  103.     for(xd=0; xd<(Width); xd++) {
  104.         xdf = (xd - wf/2.0) * scale;
  105.         ydf = (yd - hf/2.0) * scale;
  106.  
  107.         switch(FieldNum) {
  108.             case 0:
  109.                 xsf = xdf - xdf * 0.075;
  110.                 ysf = ydf - ydf * 0.075;
  111.             break;
  112.  
  113.             case 1:
  114.                 rdf = sqrt(xdf*xdf+ydf*ydf);
  115.                 tdf = atan2(ydf, xdf);
  116.                 rsf = rdf - .015;
  117.                 tsf = tdf + .02;
  118.                 xsf = rsf * cos(tsf);
  119.                 ysf = rsf * sin(tsf);
  120.             break;
  121.  
  122.             case 2:
  123.                 rdf = sqrt(xdf*xdf+ydf*ydf);
  124.                 tdf = atan2(ydf, xdf);
  125.                 rsf = rdf - .015;
  126.                 tsf = tdf - .02;
  127.                 xsf = rsf * cos(tsf);
  128.                 ysf = rsf * sin(tsf);
  129.             break;
  130.  
  131.             case 3:
  132.                 rdf = sqrt(xdf*xdf+ydf*ydf);
  133.                 tdf = atan2(ydf, xdf);
  134.                 rsf = rdf - .04;
  135.                 tsf = tdf - .005;
  136.                 xsf = rsf * cos(tsf);
  137.                 ysf = rsf * sin(tsf);
  138.             break;
  139.  
  140.             case 4: {
  141.                 float d0;
  142.                 rdf = sqrt(xdf*xdf+ydf*ydf);
  143.                 tdf = atan2(ydf, xdf);
  144.  
  145.                 d0  = 2.0 * tdf + 6.28 * rdf + A0;
  146.                 rsf = rdf + A1 * cos(d0);
  147.                 tsf = tdf + A2 * sin(d0);
  148.  
  149.                 xsf = rsf * cos(tsf);
  150.                 ysf = rsf * sin(tsf);
  151.             }
  152.             break;
  153.  
  154.             case 5:
  155.                 xsf = xdf * .97;
  156.                 if(ydf < 0.0) ysf = ydf + (cos((pow(ydf+1,2.7)  ) * 10) + 1.4) / 40;
  157.                 else          ysf = ydf - (cos((pow(ydf+1,2.7)  ) * 10) + 1.4) / 40;
  158.             break;
  159.  
  160.             case 6:
  161.                 xsf = xdf + ydf / 8.0;
  162.                 ysf = ydf - xdf / 90.0;
  163.             break;
  164.  
  165.             case 7:
  166.                 xsf = xdf + A1 * sin(A0*ydf);
  167.                 ysf = ydf + A1 * sin(A0*xdf);
  168.             break;
  169.  
  170.             case 8:
  171.                 xsf = xdf + A1 * sin(A2*ydf);
  172.                 ysf = ydf + A3 * sin(A0*xdf);
  173.             break;
  174.  
  175.             case 9:
  176.                 rdf = sqrt(xdf*xdf+ydf*ydf);
  177.                 tdf = atan2(ydf, xdf);
  178.                 rsf = sin(rdf);
  179.                 tsf = tdf - ((rdf - 0.042) * rnd (0.09));
  180.                 xsf = rsf * cos(tsf);
  181.                 ysf = rsf * sin(tsf);
  182.             break;
  183.  
  184.             case 10: // Radial Breakaway
  185.                 rdf = sqrt(xdf*xdf+ydf*ydf);
  186.                 tdf = atan2(ydf, xdf);
  187.                 rsf = rdf * (1.0+0.16*atan(0.55-rdf));
  188.                 tsf = tdf - 0.01;
  189.                 xsf = rsf * cos(tsf);
  190.                 ysf = rsf * sin(tsf);
  191.             break;
  192.  
  193.             case 11: // SOLs Waves
  194.                 xsf = xdf * 0.97;
  195.                 ysf = ydf - (cos(pow(ydf+1.0, 2.7)*10) + 1.5) / 40.0;
  196.             break;
  197.  
  198.             case 12: // SOLs Growth Formula
  199.                 xsf = xdf + A1 * cos(A0*xdf);
  200.                 ysf = ydf + A1 * cos(A0*ydf);
  201.             break;
  202.  
  203.             case 13: // Tiles
  204.                 xsf = xdf + A1 * (2.0 * (fmod(((ydf+1) * A0), 2.0)) - 1.0);
  205.                 ysf = ydf + A1 * (2.0 * (fmod(((xdf+1) * A0), 2.0)) - 1.0);
  206.             break;
  207.  
  208.             case 14: // In or out, inner Turn
  209.                 rdf = sqrt(xdf*xdf+ydf*ydf);
  210.                 tdf = atan2(ydf, xdf);
  211.                 rsf = rdf * A0;
  212.                 tsf = tdf - fabs(1.0-rdf) * 0.035;
  213.                 xsf = rsf * cos(tsf);
  214.                 ysf = rsf * sin(tsf);
  215.             break;
  216.  
  217.             case 15: // Slidering
  218.                 rdf = sqrt(xdf*xdf+ydf*ydf);
  219.                 tdf = atan2(ydf, xdf);
  220.                 rsf = fabs(rdf + A1*sin(A0*rdf));
  221.                 tsf = tdf - (A2*sgn(sin(A3*rdf)));
  222.                 xsf = rsf * cos(tsf);
  223.                 ysf = rsf * sin(tsf);
  224.             break;
  225.  
  226.             case 16: // Sine Multi-Circ
  227.                 rdf = sqrt(xdf*xdf+ydf*ydf);
  228.                 tdf = atan2(ydf, xdf);
  229.                 rsf = rdf * (0.87 + 0.05 * (1.0+sin(rdf * 15)));
  230.                 tsf = tdf;
  231.                 xsf = rsf * cos(tsf);
  232.                 ysf = rsf * sin(tsf);
  233.             break;
  234.  
  235.             case 17: // Noise
  236.                 xsf = xdf + rnd(0.11) - 0.055;
  237.                 ysf = ydf + rnd(0.11) - 0.055;
  238.             break;
  239.  
  240.             case 18: // The MAW
  241.                 rdf = sqrt(xdf*xdf+ydf*ydf);
  242.                 tdf = atan2(ydf, xdf);
  243.                 rsf = rdf + 0.0119; 
  244.                 tsf = tdf - (0.055 * ( rdf - 0.324 ) ) * ( rdf + 0.279 );
  245.                 xsf = rsf * cos(tsf);
  246.                 ysf = rsf * sin(tsf);
  247.             break;
  248.         }
  249.  
  250.         xs = xsf/scale + wf/2.0;
  251.         ys = ysf/scale + hf/2.0;
  252.  
  253.         if(xs < Width/2)  xs++;
  254.         if(ys < Height/2) ys++;
  255.  
  256.         if(xs < 0)      xs = 0;
  257.         if(xs > Width)  xs = Width;
  258.         if(ys < 0)      ys = 0;
  259.         if(ys > Height) ys = Height;
  260.  
  261.         Zoom[Width * yd + xd] = Width * ys + xs;
  262.     }
  263. }
  264.